• Authentication with user list support
• Multiple parallel binary data (file) transfers (server to client - client to server)
• Synchronous or asynchronous binary transfer modes
• Option to resume binary transfers
• Built-in chat function
• Send/process custom commands
• Clients can receive the connected clients list from server
• Secure SSL TLS connection mode
• Full unicode support
• Delphi XE2 64bit and OSX compatible
• Delphi XE5 iOS and Android compatible
• Cross platform FireMonkey example included
  

• Download TCP Server-Client Library

• In Delphi menu: File/New/Package Delphi
• Save the package with a new name eg. 'PackageTCPServerClientLibrary_Sydney.dproj' - always use a unique package name for different Delphi versions.
• In project manager (in the upper-right corner by default), right-click on 'PackageTCPServerClientLibrary_Sydney.dproj' (or the name you saved the package) and select 'Add...'
• Unit file name: click 'Browse' and select 'TCPServerClientLibrary.pas' and click 'Ok'
• In project manager (in the upper-right corner by default), right-click on 'PackageTCPServerClientLibrary_Sydney.dproj' (the name as saved) and select 'Install...'

• TMessageChat - chat strings
• TMessageCommand - command class for simple one line string commands
• TMessageBinary - binary transfer class, can be TMessageBinaryMemory (data is in memory) or TMessageBinaryFile (data is read from file)
• TMessageTransferRequest - you get this class in the result message queue if the other side wants to send a binary, fill in the wanted settings and send it back with adding it back to the action message queue
• TMessageTransferCancel - send this action to cancel a binary transfer mid transfer
• TMessageClientKick - disconnect a client

• procedure OnClientConnected(Sender: TObject; AContext: TIdContext; Client: TConnectedClient; Encoding: TEncoding);

This procedure is running in the connection's thread context (no VCL access allowed!), 'AContext' is the client's context, use it for sending commands, etc. useful for initializing a client.
'Client' is the library's client management class's client object.
You have to add 'IdContext' to the uses list for this function to compile.


• procedure OnClientDisconnected(Sender: TObject; AContext: TIdContext; Client: TConnectedClient);

This procedure is running in the connection's thread context also, 'AContext' is the client's context useful for cleaning up after a client.
You have to add 'IdContext' to the uses list for this function to compile.


• procedure OnCustomSend(Sender: TObject; AContext: TIdContext; Client: TConnectedClient; Encoding: TEncoding);

This procedure is running in the connection's thread context (no VCL access allowed!), 'AContext' is the client's context, use it for sending commands, etc. that you can process in the OnCommandReceive() event.
'Client' is the library's client management class's client object.
You have to add 'IdContext' and 'TCPLibraryClasses' (and 'IdGlobal' when using Delphi XE4 or above) to the uses list for this function to compile.


• procedure OnLoginQuery(Sender: TObject; const LoginName: String; var PassWord: String; var Deny: Boolean);

This procedure is running in the connection's thread context (no VCL access allowed!), happens when a client connects to the server. 'LoginName' is the client's login name attempt. Look-up the according pass word and if exists set 'PassWord' to the value. Set 'Deny' to 'True' if you want to deny the connection.
If no logins are added to the login list, you must implement this event.
This event can be used to look-up logins from an SQL database for example.


• procedure OnReceive(Sender: TObject; AContext: TIdContext; Client: TConnectedClient; Command: string; Encoding: TEncoding; var Handled: Boolean);

This procedure is running in the connection's thread context also, 'AContext' is the client's context, 'Command' is the string which is received from the client. Act accordingly and if the 'Command' was a proper one and processed set 'Handled' to True, this will result that the library will not process it. If you want the library to process it leave (set) 'Handled' to False.
Do not use this event to receive commands! Use 'OnReceiveMessage'. This event is mainly usable for debugging purposes to process all incomming communication.
You have to add 'IdContext' and 'TCPLibraryClasses' (and 'IdGlobal' when using Delphi XE4 or above or Indy 10.6 and above) to the uses list for this function to compile.


• procedure OnReceiveMessage(Sender: TObject; TCPServerMessage: TTCPServerMessage);

This procedure is running the thread where the TCPServerLibraryServer1 . CheckIncommingMessages; was called, so if you call CheckIncomingMessages; in the main thread this procedure is running in the main thread. Examine the 'TCPServerMessage' object's class type and act accordingly (as in the tutorial).
Do not free the 'TMessageTransferRequest' type object, if you want to accept the transfer, but send it back to the action message queue after setting it's parameters, all other objects need to be freed in your code or else the queue will fill up and memory usage will increase.
You have to add 'TCPLibraryClasses' to the uses list for this function to compile.


• procedure OnServerAfterActivate(Sender: TObject);

This event is running in the server thread (no VCL access allowed!). Happens after the server is successfully activated.


• procedure OnServerAfterDeActivate(Sender: TObject);

This event is running in the server thread (no VCL access allowed!). Happens after the server is deactivated.


• procedure OnServerBeforeActivate(Sender: TObject);

This event is running in the server thread (no VCL access allowed!). Happens before the server is activated.


• procedure OnServerBeforeDeActivate(Sender: TObject);

This event is running in the server thread (no VCL access allowed!). Happens before the server is deactivated.


• procedure OnServerThreadEnd(Sender: TObject);

This event is running in the server thread (no VCL access allowed!). Happens before the server thread terminates.


• procedure OnServerThreadStarts(Sender: TObject);

This event is running in the server thread (no VCL access allowed!). Happens when the server thread starts to run.

• procedure OnClientConnected(Sender: TObject; Client: TClient);

If connected clients list is enabled (see below) this event is called when a new client connects to the server.
You have to add 'TCPSCLClientList' to the uses list for this function to compile.


• procedure OnClientDisconnected(Sender: TObject; Client: TClient);

If connected clients list is enabled (see below) this event is called when an existing client disconnects from the server.
You have to add 'TCPSCLClientList' to the uses list for this function to compile.


• procedure OnConnected(Sender: TObject; IdTCPClient: TIdTCPClient; Encoding: TEncoding);

This procedure is running in the connection's thread context also, 'IdTCPClient' is the Indy TCP client class, use it for sending commands, etc. useful for initializing a connection.
You have to add 'IdTCPClient' (and 'IdGlobal' when using Delphi XE4 or above or Indy 10.6 and above) to the uses list for this function to compile.


• procedure OnCustomSend(Sender: TObject; IdTCPClient: TIdTCPClient; Encoding: TEncoding; MessageObject: TObject);

This procedure is running in the connection's thread context also, 'IdTCPClient' is the Indy TCP client class, use it for sending commands, which is described by MessageObject.
To use this event process the custom object that you added to the outgoing massage queue like:
TCPServerLibraryClient1 . ActionMessageQueue.Add(MyClass);
You get this MyClass as MessageObject. You have te free MessageObject before exiting this event.
You have to add 'IdTCPClient' (and 'IdGlobal' when using Delphi XE4 or above) to the uses list for this function to compile.


• procedure OnDisconnected(Sender: TObject; IdTCPClient: TIdTCPClient);

This procedure is running in the connection's thread context also, useful for cleaning up after the connection has ended.
You have to add 'IdTCPClient' (and 'IdGlobal' when using Delphi XE4 or above) to the uses list for this function to compile.


• procedure OnReceive(Sender: TObject; IdTCPClient: TIdTCPClient; Command: string; Encoding: TEncoding; var Handled: Boolean);

This procedure is running in the connection's thread context (no VCL access allowed!), 'IdTCPClient' is the Indy TCP client class, 'Command' is the string which is received from the server. Act accordingly and if the 'Command' was a proper one and processed set 'Handled' to True, this will result that the library will not process it. If you want the library to process it leave (set) 'Handled' to False.
Do not use this event to receive commands! Use 'OnReceiveMessage'. This event is mainly usable for debugging purposes to process all incomming communication.
You have to add 'IdTCPClient' (and 'IdGlobal' when using Delphi XE4 or above) to the uses list for this function to compile.


• procedure OnReceiveMessage(Sender: TObject; TCPClientMessage: TTCPServerMessage);

The same applies here as for the server.
You have to add 'TCPLibraryClasses' to the uses list for this function to compile.

var
    i, k: Integer;
    ContextList: TList;
    Context: TIdContext;
    ConnectedClient: TConnectedClient;
    UserNameIs: String;
begin
    with TCPServerLibraryServer.TCPServerThread do begin
    	ContextList := IdTCPServer.Contexts.LockList;
    	try
            for i := 0 to ContextList.Count - 1 do begin
            	Context := TObject(ContextList[i]) as TIdContext;
            	//* Do what you want with the "Context" here
            	ConnectedClients.Lock;
                try
                    ConnectedClient := ConnectedClients.Find(Context);
                    //* Get user name
                    UserNameIs := ConnectedClient.UserName;
                    //* Iterate over the send list and change all file names
                    ConnectedClient.SendList.Lock;
                    try
                        for k := 0 to ConnectedClient.SendList.Count - 1 do begin
                            if ConnectedClient.SendList.List[k] is TMessageBinary then begin
                                TMessageBinary(ConnectedClient.SendList.List[k]).FileName := 'New file name';
                    	    end;
                        end;
                    finally
                        ConnectedClient.SendList.UnLock;
                    end;
                finally
                    ConnectedClients.UnLock;
                end;
            end;
        finally
            IdTCPServer.Contexts.UnlockList;
        end;
    end;
end;

var
    MessageCommand: TMessageCommand;
begin
    MessageCommand := TMessageCommand.Create;
    MessageCommand.Command := 'RESUME';
    MessageCommand.Arguments := IntToStr(NGetFileSize('C:\Pic.jpg')) + ' "C:\Pic.jpg"';
    TCPServerLibraryClient1.ActionMessageQueue.Add(MessageCommand);

procedure TForm1.ArrivedCommand(MessageCommand: TMessageCommand);
var
    Arguments: TStringList;
    ResumeFromPosition: Int64;
    FileName: String;
begin
    if MessageCommand.Command = 'RESUME' then begin
    	Arguments := TStringList.Create;
    	try
    	    Arguments.Delimiter := ' ';
    	    Arguments.DelimitedText := MessageCommand.Arguments;
    	    ResumeFromPosition := Arguments[0];
    	    FileName := Copy(MessageCommand.Arguments,
    	    	Pos('"', MessageCommand.Arguments) + 1,
    	    	PosEx('"', MessageCommand.Arguments,
    	    	Pos('"', MessageCommand.Arguments) + 1) - Pos('"', MessageCommand.Arguments) - 1);
    	    SendResumedBinary(FileName, ResumeFromPosition);
    	finally
    	    FreeAndNil(Arguments);
    	end;
    end;
end;

procedure TForm1.SendResumedBinary(FileName: String; FromPosition: Int64);
var
    MessageBinary: TMessageBinary;
begin
    MessageBinary := TMessageBinaryFile.Create(FileName, True);
    MessageBinary.DataType := TCP_SOCKET_DATA_TYPE_FILE;
    MessageBinary.FileName := FileName;
    MessageBinary.Resume := True;
    MessageBinary.StartPosition := FromPosition;
    TCPServerLibraryServer1.ActionMessageQueue.Add(MessageBinary);
end;

procedure TForm1.ArrivedTransferRequest(MessageTransferRequest: TMessageTransferRequest);
begin
    if MessageTransferRequest.DataType = TCP_SOCKET_DATA_TYPE_FILE then begin
        if MessageTransferRequest.FileName = 'C:\Pic.jpg' then begin
            TransferID := MessageTransferRequest.ID;
            MessageTransferRequest.Accept := True;
            MessageTransferRequest.SaveToFile := True;
            MessageTransferRequest.SaveToFileName := 'C:\Pic.jpg';
            MessageTransferRequest.Resume := True;
            MessageTransferRequest.StartPosition := NGetFileSize('C:\Pic.jpg');
            TCPServerLibraryClient1.ActionMessageQueue.Add(MessageTransferRequest);
        end;
    end;
end;

    TCPServerLibraryServer.Bindings.Clear;
    with TCPServerLibraryServer.Bindings.Add do begin
        IP := '192.168.0.101';
        Port := 2014;
    end;

Uses
    Androidapi.Helpers,
    DPF.Android.DPFUtils;

	TCPServerLibraryServer.Bindings.Clear;
	with TCPServerLibraryServer.Bindings.Add do begin
		IP := JStringToString(TJDPFUtils.JavaClass.getIPAddress(True));
		Port := 2014;
	end;

• 'Command': Do not use numbers (as strings) in the range 100-999 as they are already used and reserved by the library.

procedure TForm1.TCPServerLibraryServer1ClientConnected(Sender: TObject; AContext: TIdContext; Client: TConnectedClient; Encoding: TEncoding);
begin
    //* This is for the connected client list for the clients to receive, turn off if not needed, generates extra trafic. Also requires that TCPServerLibraryServer1.SendUserListToClients is True.
    //* You can decide from eg. login name if the user has right for this.
    Client.ExpectsClientList := True;
end;

    procedure OnClientConnected(Sender: TObject; Client: TClient);
    procedure OnClientDisconnected(Sender: TObject; Client: TClient);

• Running a TLS secured server requires an SSL certificate. For example: https://secure.ksoftware.net/ssl_certs.html
• Helper3delite unit available at: Helper3delite
• D.P.F Delphi Android Native Components